{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-09-09T13:26:16.279460Z",
     "start_time": "2025-09-09T13:26:14.120870Z"
    }
   },
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "outputs": [],
   "execution_count": 2
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1 特征中含有字符串的时候（当成类别），如何做特征抽取"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def dictvec():\n",
    "    \"\"\"\n",
    "    字典数据抽取\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 实例化\n",
    "    # sparse改为True,输出的是每个不为零位置的坐标，稀疏矩阵可以节省存储空间\n",
    "    #矩阵中存在大量的0，sparse存储只记录非零位置，节省空间的作用\n",
    "    #Vectorizer中文含义是矢量器的含义\n",
    "    dict1 = DictVectorizer(sparse=True)  # 把sparse改为True看看\n",
    "\n",
    "    #每个样本都是一个字典，有三个样本\n",
    "    # 调用fit_transform的作用是，把字典中的类别数据转换成特征\n",
    "    # 将字典中的字符数据转换成特征one-hot编码\n",
    "    # fit_transform拟合数据，transform转换数据\n",
    "    data = dict1.fit_transform([{'city': '北京', 'temperature': 100},\n",
    "                                {'city': '上海', 'temperature': 60},\n",
    "                                {'city': '深圳', 'temperature': 30}])\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "    print(type(data.toarray()))\n",
    "    print('-' * 50)\n",
    "    # 字典中的一些类别数据，分别进行转换成特征\n",
    "    print(dict1.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(dict1.inverse_transform(data))  #去看每个特征代表的含义，逆转回去\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "dictvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-09-09T13:26:16.381689Z",
     "start_time": "2025-09-09T13:26:16.366675Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Compressed Sparse Row sparse matrix of dtype 'float64'\n",
      "\twith 6 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t1.0\n",
      "  (0, 3)\t100.0\n",
      "  (1, 0)\t1.0\n",
      "  (1, 3)\t60.0\n",
      "  (2, 2)\t1.0\n",
      "  (2, 3)\t30.0\n",
      "--------------------------------------------------\n",
      "[[  0.   1.   0. 100.]\n",
      " [  1.   0.   0.  60.]\n",
      " [  0.   0.   1.  30.]]\n",
      "<class 'numpy.ndarray'>\n",
      "--------------------------------------------------\n",
      "['city=上海' 'city=北京' 'city=深圳' 'temperature']\n",
      "--------------------------------------------------\n",
      "[{'city=北京': np.float64(1.0), 'temperature': np.float64(100.0)}, {'city=上海': np.float64(1.0), 'temperature': np.float64(60.0)}, {'city=深圳': np.float64(1.0), 'temperature': np.float64(30.0)}]\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 一段英文文本如何变为数值类型"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def couvec():\n",
    "    # 实例化CountVectorizer，默认按，‘ ’来分词\n",
    "    # max_df, min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于等于max_df\n",
    "    # max_df, min_df小数(0-1之间的）：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词，默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "    # 统计整个文集中每个词的出现次数，把词作为特征，每个样本对应特征的值是词频\n",
    "\n",
    "    # 调用fit_transform输入并转换数据\n",
    "\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is  short,i like python life\",\n",
    "         \"life is too long,i dislike python\",\n",
    "         \"life is short\"])\n",
    "\n",
    "    # 打印结果,把每个词都分离了\n",
    "    print(vector.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(res)\n",
    "    print('-' * 50)\n",
    "    print(type(res))\n",
    "    # 对照feature_names，标记每个词出现的次数\n",
    "    print('-' * 50)\n",
    "    print(res.toarray())  #稀疏矩阵转换为数组\n",
    "    print('-' * 50)\n",
    "    #拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "\n",
    "couvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-09-09T13:26:16.439564Z",
     "start_time": "2025-09-09T13:26:16.429088Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 10 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 一段汉字文本如何数值化，对于汉字不能用空格来分割"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def countvec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化,单个汉字单个字母不统计，因为单个汉字字母没有意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([\"人生苦短，我喜欢 python python\", \"人生漫长，不用 python\"])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(data)  #稀疏存储，只记录非零位置\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "countvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-09-09T13:26:16.511828Z",
     "start_time": "2025-09-09T13:26:16.505258Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '我喜欢']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 6 stored elements and shape (2, 5)>\n",
      "  Coords\tValues\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.3 掌握如何对中文进行分词"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\n",
    "        \"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1))\n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    print('-' * 50)\n",
    "    c1 = ' '.join(content1)\n",
    "    c2 = ' '.join(content2)\n",
    "    c3 = ' '.join(content3)\n",
    "\n",
    "    return c1, c2, c3\n",
    "\n",
    "\n",
    "def hanzivec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()  #jieba分词好的中文文本\n",
    "    print('-' * 50)\n",
    "    print(c1)  #把分词好的文本打印出来\n",
    "    print(c2)\n",
    "    print(c3)\n",
    "    print('-' * 50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(cv.get_feature_names_out())  #把处理好后的特征名称打印出来\n",
    "\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "# cutword()\n",
    "hanzivec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-09-09T13:26:17.500633Z",
     "start_time": "2025-09-09T13:26:16.711894Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Building prefix dict from the default dictionary ...\n",
      "Loading model from cache C:\\Users\\豆豆\\AppData\\Local\\Temp\\jieba.cache\n",
      "Loading model cost 0.779 seconds.\n",
      "Prefix dict has been built successfully.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1.4 tf-idf"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# 规范{'l1'，'l2'}，默认='l2'\n",
    "# 每个输出行都有单位范数，或者：\n",
    "#\n",
    "# 'l2'：向量元素的平方和为 1。当应用 l2 范数时，两个向量之间的余弦相似度是它们的点积。\n",
    "#\n",
    "# 'l1'：向量元素的绝对值之和为 1。参见preprocessing.normalize。\n",
    "\n",
    "# smooth_idf布尔值，默认 = True\n",
    "# 通过在文档频率上加一来平滑 idf 权重，就好像看到一个额外的文档包含集合中的每个术语恰好一次。防止零分裂。\n",
    "# 比如训练集中有某个词，测试集中没有，就是生僻词，就会造成n(x)分母为零，log(n/n(x)),从而出现零分裂\n",
    "\n",
    "def tfidfvec():\n",
    "    \"\"\"\n",
    "    中文特征值化,计算tfidf值\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()\n",
    "\n",
    "    print(c1, c2, c3)\n",
    "    # print(type([c1, c2, c3]))\n",
    "    tf = TfidfVectorizer(smooth_idf=True)\n",
    "\n",
    "    data = tf.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(tf.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(type(data))\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "tfidfvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-09-09T13:26:17.538318Z",
     "start_time": "2025-09-09T13:26:17.526186Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "cell_type": "markdown",
   "source": "# 2 特征处理，不同的特征拉到到同一个量纲，标准化归一化相当于同比例缩放",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理\n",
    "    :return: NOne\n",
    "    \"\"\"\n",
    "    # 归一化缺点 容易受极值的影响\n",
    "    #feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "    print(type(data))\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    out = mm.transform([[1, 2, 3, 4], [6, 5, 8, 7]])\n",
    "    print(out)\n",
    "    return None\n",
    "    #transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "\n",
    "\n",
    "mm()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-09-09T13:26:17.609042Z",
     "start_time": "2025-09-09T13:26:17.599298Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "--------------------------------------------------\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.8         1.5        -0.4        -5.5       ]]\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "cell_type": "code",
   "source": "(1 - 60) / 30",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-09-09T13:26:17.662048Z",
     "start_time": "2025-09-09T13:26:17.653689Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.9666666666666666"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 9
  },
  {
   "cell_type": "code",
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，只均值为0，方差为1的分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.],\n",
    "                              [2., 4., 2.],\n",
    "                              [4., 6., -1.]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)\n",
    "    print('-' * 50)\n",
    "    print(std.var_)  #方差\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return data\n",
    "\n",
    "\n",
    "data = stand()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-09-09T13:26:17.746200Z",
     "start_time": "2025-09-09T13:26:17.738943Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-09-09T13:26:17.838310Z",
     "start_time": "2025-09-09T13:26:17.830716Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#如何求方差\n",
    "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 11
  },
  {
   "cell_type": "code",
   "source": [
    "type(data)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-09-09T13:26:17.892289Z",
     "start_time": "2025-09-09T13:26:17.886811Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 12
  },
  {
   "cell_type": "code",
   "source": [
    "std1 = StandardScaler()\n",
    "#为了证明上面输出的结果的均值是为0的，方差为1\n",
    "data1 = std1.fit_transform([[-1.06904497, -1.35873244, 0.98058068],\n",
    "                            [-0.26726124, 0.33968311, 0.39223227],\n",
    "                            [1.33630621, 1.01904933, -1.37281295]])\n",
    "# print(data1)  #这个并不是我们想看的，没意义\n",
    "# 均值\n",
    "print(std1.mean_)\n",
    "# 方差\n",
    "print(std1.var_)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-09-09T13:26:17.949705Z",
     "start_time": "2025-09-09T13:26:17.942709Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0.]\n",
      "[1.         1.         1.00000001]\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "cell_type": "code",
   "source": "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-09-09T13:26:18.036918Z",
     "start_time": "2025-09-09T13:26:18.031656Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 14
  },
  {
   "cell_type": "code",
   "source": "(1 - 2.333) / np.sqrt(1.55555)",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-09-09T13:26:18.095671Z",
     "start_time": "2025-09-09T13:26:18.090025Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(-1.068779614944516)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 15
  },
  {
   "cell_type": "markdown",
   "source": [
    "## transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值,不会重新计算均值方差"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 3 缺失值处理\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "#下面是填补，针对删除，可以用pd和np\n",
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return:None\n",
    "    \"\"\"\n",
    "    # NaN, nan,缺失值必须是这种形式，如果是？号(或者其他符号)，就要replace换成这种\n",
    "    #mean, median, most_frequent(众数), constant\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')\n",
    "    # im = SimpleImputer(missing_values=np.nan, strategy='constant', fill_value=0)\n",
    "\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "    print(type(data))\n",
    "\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "im()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-09-09T13:26:18.150345Z",
     "start_time": "2025-09-09T13:26:18.142527Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "execution_count": 16
  },
  {
   "cell_type": "code",
   "source": "11 / 3",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-09-09T13:26:18.226188Z",
     "start_time": "2025-09-09T13:26:18.219834Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.6666666666666665"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 17
  },
  {
   "cell_type": "code",
   "source": "np.nan + 10",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-09-09T13:26:18.294901Z",
     "start_time": "2025-09-09T13:26:18.288428Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 18
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 4 降维\n",
    "# 降维就是特征数变少\n",
    "# 降维可以提高模型训练速度（特征变少）"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择-删除低方差的特征\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.6)\n",
    "\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "    print(type(data))\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))\n",
    "    print(type(var.get_support(True)))\n",
    "    return None\n",
    "\n",
    "\n",
    "var()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-09-09T13:27:43.181657Z",
     "start_time": "2025-09-09T13:27:43.174684Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[[0]\n",
      " [4]\n",
      " [1]]\n",
      "--------------------------------------------------\n",
      "The surport is [2]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "execution_count": 25
  },
  {
   "cell_type": "code",
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。方差比例是指 得到输出的每一列的方差值和除以原有数据方差之和。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    original_value = np.array([[2, 8, 4, 5],\n",
    "                               [6, 3, 0, 8],\n",
    "                               [5, 4, 9, 1]])\n",
    "    print(np.var(original_value, axis=0).sum())  #最初数据每一列的方差，求和\n",
    "    # np.var(original_value, axis=0).sum()\n",
    "    print('-' * 50)\n",
    "    pca = PCA(n_components=0.99)#一般都要大于0.9，看模型调参\n",
    "\n",
    "    data = pca.fit_transform(original_value)\n",
    "\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差和\n",
    "    print(np.var(data, axis=0).sum())\n",
    "    print('-' * 50)\n",
    "    print(pca.explained_variance_ratio_)\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-09-09T03:29:10.064488Z",
     "start_time": "2025-09-09T03:29:10.038041Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[-3.13587302e-16  3.82970843e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333346\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 24
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "outputs": [
    {
     "data": {
      "text/plain": "0.7499999999999999"
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": "22 / 29.333333333333336",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T03:08:17.259124100Z",
     "start_time": "2024-07-11T03:08:17.248038900Z"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "x = np.random.rand(10000)  #每个的概率\n",
    "t = np.arange(len(x))\n",
    "plt.plot(t, x, 'g.', label=\"Uniform Distribution\")\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-09-09T10:00:01.296479Z",
     "start_time": "2025-09-09T10:00:00.579959Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 25
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-09-09T10:13:45.347107Z",
     "start_time": "2025-09-09T10:13:45.340941Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import numpy as np\n",
    "a=np.array(range(24)).reshape(2,3,4)\n",
    "print(a.shape)\n",
    "# print(a)\n",
    "# print(np.rollaxis(a,0,3))#前面的轴转到后面\n",
    "print(np.rollaxis(a,0,3).shape)\n",
    "# print(np.rollaxis(a,2,0))\n",
    "print(np.rollaxis(a,2,0).shape)#将二轴旋转到0轴\n",
    "print(np.rollaxis(a,2,1).shape)#将二轴旋转到1轴\n",
    "print(np.rollaxis(a,1,2).shape)#将1轴旋转到2轴的前面\n",
    "a=a.astype(float)\n",
    "a[a>20]=np.nan\n",
    "print(a)\n",
    "print(np.count_nonzero(a!=a))"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3, 4)\n",
      "(3, 4, 2)\n",
      "(4, 2, 3)\n",
      "(2, 4, 3)\n",
      "(2, 3, 4)\n",
      "[[[ 0.  1.  2.  3.]\n",
      "  [ 4.  5.  6.  7.]\n",
      "  [ 8.  9. 10. 11.]]\n",
      "\n",
      " [[12. 13. 14. 15.]\n",
      "  [16. 17. 18. 19.]\n",
      "  [20. nan nan nan]]]\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 39
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-09-09T10:31:44.622543Z",
     "start_time": "2025-09-09T10:31:44.521305Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "x=np.random.randint(1,11,size=20)\n",
    "# print(x)\n",
    "y=np.random.randint(1,11,size=20)\n",
    "x_ticks=[0.5]\n",
    "_x=0.5\n",
    "plt.rcParams[\"font.family\"] = [\"SimHei\"]\n",
    "# 解决负号显示问题（可选）\n",
    "plt.rcParams['axes.unicode_minus'] = False  # 正确显示负号\n",
    "while _x<10:\n",
    "    _x+=0.5\n",
    "    x_ticks.append(_x)\n",
    "plt.plot(x,x_ticks, 'r.', label=\"刻度练习\")\n",
    "plt.xticks(x_ticks)\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.show()"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 46
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
